/*
Copyright (c) [2019年5月1日] [吴超]
[MBT_studio] is licensed under Mulan PSL v2.
You can use this software according to the terms and conditions of the Mulan PSL v2.
You may obtain a copy of Mulan PSL v2 at:
         http://license.coscl.org.cn/MulanPSL2
THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
See the Mulan PSL v2 for more details.
*/
#pragma once

#include "Widget.h"

void f_ui绘制模板_单色图标绘制(S_2D画布* s, S_图标绘制ID& id, uint16 属性ID, std::string 图标集);
void f_ui绘制模板_图标绘制(S_2D画布* s, S_图标绘制ID& id, uint16 属性ID, std::string 图标集);
void f_ui绘制模板_动态线(S_2D画布* s, S_图标绘制ID& ID, uint16 属性ID, float32 lw = 1.0);
void f_ui绘制模板_画行文本(S_2D画布* s, S_行文本绘制ID& 文本ID, uint16 属性ID, uint16 字号);
bool f_ui绘制模板_重置凸矩形数量(S_2D画布* 画布, S_单色绘制ID& id, uint32 num);



Inline void f_ui绘制模板_间接内存resize(S_2D画布* s, const S_凸边图元& 图元, uint32 num) {
	f_buf_gresize(*图元.变换, num);
	f_buf_gresize(*图元.颜色, num);
	f_buf_gresize(*图元.线属性, num);
	
	f_vg_resize间接参数(s, 图元.层, num);
	f_vg_set实例数量(s, 图元.层, num);
}


Inline bool f_ui绘制模板_resize文本变换(S_2D画布* s, const S_单色文本绘制ID& ID, uint32 num) {
	bool 重置数量 = false;
	重置数量 |= f_vg_resize参数实例(s, ID.id_变换, num);
	重置数量 |= f_vg_resize参数实例(s, ID.id_颜色, num);
	重置数量 |= f_vg_resize参数实例(s, ID.id_文本, num);
	return 重置数量;
}


Inline void f_ui绘制模板_unmap参数指针(S_2D画布* s, const S_单色绘制ID& 边面ID) {
	f_vg_unmapGPU参数(s, 边面ID.id_图元);
	f_vg_unmapGPU参数(s, 边面ID.id_变换);
	f_vg_unmapGPU参数(s, 边面ID.id_颜色);
}

Inline S_sf_GPU映射面单色 f_ui绘制模板_map参数指针(S_2D画布* s, const S_凸边图元& 图元) {
	S_sf_GPU映射面单色 ptr;
	ptr.p间接 = f_vg_map间接参数(s, 图元.层);
	ptr.p变换 = f_buf_Mat3X2_ptr(*图元.变换);
	ptr.p颜色 = f_buf_UI32_ptr(*图元.颜色);

	ptr.p线属性 = f_buf_线属性_ptr(*图元.线属性);
	return ptr;
}

Inline void f_ui绘制模板_unmap参数指针(S_2D画布* s, S_单色文本绘制ID& 边面ID) {
	f_vg_unmapGPU参数(s, 边面ID.id_变换);
	f_vg_unmapGPU参数(s, 边面ID.id_颜色);
	f_vg_unmapGPU参数(s, 边面ID.id_文本);
}

Inline void f_ui绘制模板_unmap间接参数指针(S_2D画布* s, S_单色绘制ID& ID) {
	f_vg_unmapGPU参数(s, ID.id_变换);
	f_vg_unmapGPU参数(s, ID.id_颜色);
	//f_vg_unmap间接参数(s, ID.id_元素);
}

Inline void f_ui绘制模板_线图形GPU内存分配(S_2D画布* s, const S_单色绘制ID& ID, uint32 num) {
	f_vg_resize参数实例(s, ID.id_变换, num);
	f_vg_resize参数实例(s, ID.id_线属性, num);
	f_vg_resize间接参数(s, ID.id_元素, num);
	//f_vg_resize参数实例(s, ID.id_图元, num);
	f_vg_set实例数量(s, ID.id_元素, num);
}

Inline void f_ui绘制模板_unmap线绘制参数指针(S_2D画布* s, S_单色绘制ID& ID) {
	f_vg_unmapGPU参数(s, ID.id_变换);
	f_vg_unmapGPU参数(s, ID.id_线属性);
	//f_vg_unmap间接参数(s, ID.id_元素);
}






class ui_绘制模板_Vec {
	S_单色边面ID		m_背景ID;
	
	S_单色文本绘制ID	m_分量数值文本;
	S_单色文本绘制ID	m_分量名称文本;
	S_2D画布*			m_画布;

	

	S_sf_单色边面GPU映射	m_背景Prt;
	S_sf_文字GPU参数映射	m_Text数值Prt;
	S_sf_文字GPU参数映射	m_Text名称Prt;
	
public:
	ui_绘制模板_Vec();

	float32				m_字号;

	void f_Layout(C_Widget* w);
	
};





class ui_绘制模板_行文本绘制 : public ui_绘制模板 {
	S_行文本绘制ID   m_文本;
	S_2D画布*        m_画布;
	const S_Font*    m_字体;
	uint32           m_单行字符最大数量;
public:
	ui_绘制模板_行文本绘制(uint16 单行字符最大数量 = 20);
	~ui_绘制模板_行文本绘制();
	
	float32				m_字号;
	uint16				m_画布属性;
	S_sf_文字GPU参数映射	m_Prt;

	void	f_Draw(S_2D画布* 画布, const S_Font* 字体, uint16 属性ID);
	void	f_alloc(uint32 变换num, uint32 所有字符num);
	void	f_设置文本(const S_Rect2Df& rect, const S_RGBA8UI& color, uint32 变换GPU偏移, std::wstring txt);
	void	f_居中绘制文本(const S_Rect2Df& rect, const S_RGBA8UI& color, uint32 变换GPU偏移, std::wstring txt);
	void	f_绘制文本(const S_Rect2Df& rect, const S_RGBA8UI& color, uint32 变换GPU偏移, std::wstring txt, E_对齐方式 方式, float32 缩放 = 1);
	void	f_绘制刻度数字(S_Rect2Df& rect, uint32 num, vec2 开始_步进, float32 间隔);
	void	f_Close(S_2D画布* 画布);
	void	f_Close(uint32 num = 0);

};






class ui_绘制模板_编辑框编辑状态 {
	S_单色绘制ID		m_背景ID;
	S_单色绘制ID		m_选取ID;
	S_单色文本绘制ID	m_编辑文本;

	S_2D文本对象		m_编辑文本对象;

	S_单色绘制ID		m_光标ID;

public:
	ui_绘制模板_编辑框编辑状态();

	float32				m_字号;


	void f_Draw点(S_2D画布* 画布, uint16 属性ID, uint16 字号);

	void f_开启编辑(S_2D画布* 画布, C_Widget* w, const S_Font& 字体);
	void f_当前输入(S_2D画布* 画布, C_Widget& w, const S_Font& 字体, std::wstring& text);
	void f_输入完成(S_2D画布* 画布);
	
	void f_框选(S_2D画布* 画布, C_文本框* box);
	void f_GPU参数修改(S_2D画布* 画布, C_文本框& w);

};










class ui_绘制模板_画预设图形 : public ui_绘制模板 {
	
	S_2D画布*          m_画布;
	//S_sf_GPU映射面单色 m_间接Ptr;
	
public:
	ui_绘制模板_画预设图形();
	~ui_绘制模板_画预设图形();

	uint8		m_属性;
	S_凸边图元	m_图元;

	void	f_Draw(S_2D画布* 画布, const S_凸边图元& 链接参数, E_笔刷类型 笔刷, float32 线宽 = 1.0);
	
	void	f_alloc(uint32 num);
	//void	f_End(const S_单色绘制ID& ID);
	
	void	f_setColor(uint32 id, const S_RGBA8UI& C);
	void	f_绘制滚动条(uint32 gpuOffset, C_Widget* 滚动条);
	uint32	f_fill顶点(vec2* 顶点, uint32 num);
	void	f_set单色填充(uint32 id, const mat3X2& mat, const S_RGBA8UI& C, const uvec2& 图元ID, float32 线宽 = 1.0);
	void	f_set单色线(uint32 id, const mat3X2& mat, const S_LineProp& C, const uvec2& 图元ID, float32 线宽 = 1.0);
	void	f_set色轮(uint32 id, const mat3X2& mat, const uvec2& 图元ID, const S_ColorTake& ct);
	void	f_set纹理属性(uint32 id, const mat3X2& mat, const uvec2& 图元ID, S_TextueProp& texProp);
	
	void	f_Close(uint32 num = 0);



};



class ui_绘制模板_图标 : public ui_绘制模板 {
	S_图标绘制ID m_ID;
	
	S_2D画布* m_画布;
	S_sf_图标GPU映射	m_Prt;

public:
	ui_绘制模板_图标();
	~ui_绘制模板_图标();

	void	f_Draw单色(S_2D画布* 画布, uint16 属性ID, std::string ico集);
	void	f_Draw彩色(S_2D画布* 画布, uint16 属性ID, std::string ico集);
	void	f_alloc(uint32 num);
	void	f_set(std::string ico, uint32 offset, const mat3X2 mat, const S_RGBA8UI 颜色);
	void	f_Close();
	//void	f_GPU参数修改(uint32 id, S_2D画布* 画布, mat3X2& mat, S_RGBA8UI& FC, S_RGBA8UI& EC);

};





class ui_绘制模板_刻度线 {
	S_图标绘制ID m_ID;
	S_GPU内存块索引 id_变换;
	S_GPU内存块索引 id_颜色;

	mat3X2* m_Mat;
	uint32* m_线Color;
	uint32* m_文字Color;
	
	S_2D画布* m_画布;

	
public:
	ui_绘制模板_刻度线();
	~ui_绘制模板_刻度线();

	vec2	m_间隔比例;

	void	f_Draw(S_2D画布* 画布, uint16 属性ID);
	void	f_Draw网格(S_2D画布* 画布, uint16 属性ID);
	void	f_alloc(uint32 num);
	void	f_set(uint32 线num, const mat3X2 mat, S_RGBA8UI 颜色, uint32 offset = 0);
	void	f_set(uint32 offset, uint32 线num, const mat3X2 mat, S_RGBA8UI 颜色);
	
};





class ui_绘制模板_块文本绘制 : public ui_绘制模板 {
	S_单色文本绘制ID		m_文本;
	S_单色文本绘制ID		m_行号;
	//S_2D文本对象			m_文本对象;
	S_sf_文字GPU参数映射	m_映射指针;
	S_sf_文字GPU参数映射	m_行号映射指针;

	S_单色绘制ID			m_光标ID;
	S_单色绘制ID			m_选取ID;

	S_2D画布*				m_画布;

public:
	ui_绘制模板_块文本绘制();

	float32				m_字号;
	uint16				m_单行字符最大数量;


	void					f_Draw点(S_2D画布* 画布, uint16 字号, const S_Font& 字体, uint16 属性ID);
	S_sf_文字GPU参数映射	f_GPU参数修改_begin(S_2D画布* 画布, uint32 num, uint32 行);
	void					f_填充文本(S_2D画布* 画布, std::wstring txt, const S_RGBA8UI& color, vec2 pos, uint32 offset);
	void					f_填充文本(S_2D画布* 画布, const S_文档文本& txt, vec2 pos, const S_Font& 字体, int16 行距);
	void					f_GPU参数修改_end(S_2D画布* 画布);

	void f_开启编辑(S_2D画布* 画布, C_Widget* w);
	void f_输入(S_2D画布* 画布, C_文本框* box, std::wstring& text);
	void f_输入完成(S_2D画布* 画布, C_文本框* box);

	void f_框选(S_2D画布* 画布, C_文本框* box);

};





class ui_绘制模板_曲线 {
	S_单色绘制ID			m_背景;

	
	S_板载缓存* m_曲线ID;
	uint32		m_点元素;
	uint32		m_线元素;

	
	S_CurvePoint*	m_曲线点Ptr;
	uint32*			m_曲线IDPtr;

	std::vector<std::vector<uvec2>> m_线点ID;

	S_2D画布*	m_画布;
	suvec2		m_Dim;
	
public:
	ui_绘制模板_曲线();

	uint8		m_属性;
	S_板载缓存* m_曲线点;
	uint32		m_点数量;

	void f_Draw控制点(S_2D画布* 画布, uint16 属性ID);
	void f_Draw(S_2D画布* 画布, uint16 属性ID, bool 多曲线 = false);

	void f_begin(uint32 线段区数量);
	void f_end();

	void f_setPoint(uint32 offset, const S_CurvePoint& 曲线点);
	void f_setPointColor(uint32 offset, const uint32 color);
	void f_setPointColor(uint32 offset, const S_RGBA8UI& color);
	void f_setPointSelect(uint32 offset, uint32 b);
	void f_setPointType(uint32 offset, uint32 b);
	void f_setLine(uint32 offset, uint16 left_id, uint16 rigth_id);

	void f_插入点(const S_CurvePoint& 曲线点, const S_RGBA8UI& color, uint32 链接ID, uint64 offset);

	void f_map();
	void f_unmap();
};




class ui_绘制模板_自定义线 {
	S_图标绘制ID     m_ID;
	S_2D画布*        m_画布;
	
	S_sf_单色GPU映射 m_Prt;
	
public:
	ui_绘制模板_自定义线();
	~ui_绘制模板_自定义线();

	uint32	m_NextID;
	std::vector<vec2> lines;

	void	f_Draw(S_2D画布* 画布, uint16 属性ID, E_笔刷类型 笔刷 = E_笔刷类型::e_单色填充);
	void	f_alloc(uint32 num, const S_RGBA8UI& C = { 0,0,0,255 });
	void	f_End();


	void	f_set下一个顶点(const vec2& pos, const S_RGBA8UI& C);
	void	f_set顶点(uint32 id, const vec2& pos);
	void	f_set顶点(uint32 id, const vec2& pos, const S_RGBA8UI& C);
	void	f_Close(uint32 num = 0);
	
	void	f_get线坐标();
};




class ui_绘制模板_渐变 {
	S_2D画布* m_画布;

	S_sf_单色GPU映射		m_Prt;
	E_方向 m_方向;

public:
	ui_绘制模板_渐变();

	S_渐变图元	m_图元;

	void	f_Draw(S_2D画布* 画布, S_渐变图元 图元属性, E_方向 方向);
	void	f_alloc(uint32 num, const std::vector<vec4>& cp);
	void	f_End();

	void	f_填充渐变点(uint32 id, const mat3X2 mat, const uvec2& 图元ID);

	void	f_Close(uint32 num = 0);

};




class ui_绘制模板_表格 {
	S_2D画布* m_画布;

	S_GPU内存块索引  m_表格线;
	S_GPU内存块索引  m_颜色;
public:
	ui_绘制模板_表格();
	~ui_绘制模板_表格();

	//S_渐变图元	m_图元;
	uint32	m_层;
	vec2    m_大小;

	void	f_Draw(S_2D画布* 画布, uint16 属性ID);
	void	f_fill(uint32 hNum, uint32 vNum);
	
	void	f_Close(uint32 num = 0);
};




class ui_绘制模板_2D矢量图形 {
	S_2D画布* m_画布;

	//S_GPU内存块索引  m_顶点坐标;
	S_GPU内存块索引  m_变换;
	S_GPU内存块索引  m_颜色;
public:
	ui_绘制模板_2D矢量图形();
	~ui_绘制模板_2D矢量图形();

	uint32	m_层;

	void f_Draw(S_2D画布* 画布, uint16 属性ID, bool 填充);
	void f_fill(const mat3X2 mat, std::vector<vec2>& 顶点坐标, std::vector<uint32>& 顶点索引);
	void f_Close(uint32 num = 0);
};



class ui_绘制模板_纹理 {
	S_2D画布* m_画布;

	S_GPU内存块索引 m_纹理变换;
	S_GPU内存块索引 m_纹理属性;
	uint32          m_层ID;
public:
	ui_绘制模板_纹理();
	~ui_绘制模板_纹理();

	uint32	m_层;

	void f_Draw(S_2D画布* 画布, uint16 属性ID, E_笔刷类型 笔刷 = E_笔刷类型::e_纹理, S_纹理* 纹理 = nullptr);
	void f_alloc(uint32 num);
	void f_set(uint32 id, const mat3X2& mat, const uvec2& 图元ID, const S_RGBA8UI& C, const S_TextueProp& texProp = {});
	void f_绑定纹理(S_纹理* text, uint32 id, const S_RGBA8UI& C = {});
	//void f_set纹理属性(uint32 id, const mat3X2& mat, const uvec2& 图元ID, S_TextueProp& texProp);
	void f_Close(uint32 num = 0);
};



class ui_绘制模板_线段 {
	S_2D画布* m_画布;

	uint32	    m_层ID;
	uint8		m_属性;
	S_凸边图元	m_图元;
	

	S_GPU内存块索引  m_线段数据;

public:
	ui_绘制模板_线段();
	~ui_绘制模板_线段();

	void	f_Draw(S_2D画布* 画布, uint16 属性ID, E_笔刷类型 笔刷 = E_笔刷类型::e_圆公切链接线);
	void	f_alloc(uint32 num);
	
	void	f_set(uint32 id, const S_CurvePoint& point);
	void	f_Close(uint32 num = 0);

};








//void f_ui绘制模板_绘制图标(S_2D画布* s, uint16 变换ID, uint16 图标UVID, uint16 颜色ID, uint16& 元素ID, uint16 属性ID);

//bool f_ui绘制模板_重置凸矩形数量(S_2D画布* 画布, S_单色边面ID& id, uint32 num);

//Inline S_sf_GPU映射面单色 f_ui绘制模板_map线绘制参数指针(S_2D画布* s, const S_单色绘制ID& ID) {
//	S_sf_GPU映射面单色 ptr;
//	ptr.p变换 = f_vg_map变换(s, ID.id_变换);
//	//ptr.p线属性 = f_buf_线属性_ptr(s, ID.id_线属性);
//	ptr.p间接 = f_vg_map间接参数(s, ID.id_元素);
//	return ptr;
//}

//Inline S_sf_文字GPU参数映射 f_ui绘制模板_map参数指针(S_2D画布* s, S_单色文本绘制ID& 边面ID) {
//	S_sf_文字GPU参数映射 指针 = {};
//	指针.coord = f_vg_map变换(s, 边面ID.id_变换);
//	指针.color = f_vg_map单色(s, 边面ID.id_颜色);
//	指针.text = f_vg_map字符(s, 边面ID.id_文本);
//	return 指针;
//}

//Inline S_sf_GPU映射面单色 f_ui绘制模板_map间接参数指针(S_2D画布* s, const S_单色绘制ID& ID) {
//	S_sf_GPU映射面单色 ptr;
//	ptr.p变换 = f_vg_map变换(s, ID.id_变换);
//	ptr.p颜色 = f_vg_map单色(s, ID.id_颜色);
//	ptr.p间接 = f_vg_map间接参数(s, ID.id_元素);
//	return ptr;
//}

//Inline void f_ui绘制模板_文本绘制(S_2D画布* 画布, S_单色文本绘制ID& ID, uint16 属性ID, const S_Font& 字体) {
//	ID.id_变换 = f_vg_gen变换(画布, 0);
//	ID.id_颜色 = f_vg_gen颜色(画布, 0);
//	//m_文本.id_文本 = f_vg_gen文本ID(画布);
//	ID.笔刷 = f_vg_gen文本块笔刷(画布, ID.id_变换, ID.id_颜色, 属性ID, 字体);
//	ID.id_元素 = f_vg_画文本(画布, ID.笔刷);
//}

//Inline void f_ui绘制模板_填充GPU内存行文字(S_sf_文字GPU参数映射& m, const std::wstring& text, const S_RGBA8UI& color, const vec2& pos, uint32 offset) {
//	m.color[offset] = f_PackData4X8(color);
//	m.coord[offset].row0 = pos;
//	m.coord[offset].row1 = { 64, float32(text.size()) };
//	m.coord[offset].row2 = { 0, 0 };
//}

//Inline S_sf_单色GPU映射 f_ui绘制模板_map参数指针(S_2D画布* s, const S_单色绘制ID& 边面ID) {
//	S_sf_单色GPU映射 指针 = {};
//
//	指针.p变换 = f_vg_map变换(s, 边面ID.id_变换);
//	指针.p颜色 = f_vg_map单色(s, 边面ID.id_颜色);
//	指针.p图元 = f_vg_map图元(s, 边面ID.id_图元);
//
//	return 指针;
//}

//void f_ui绘制模板_编辑文本(S_2D画布* s, uint16& 文字ID, uint16& 变换ID, uint16& 颜色ID, uint16& 元素ID, uint16 属性ID, S_2D文本对象& tObj, uint16 字号);
//void f_ui绘制模板_画行文本(S_2D画布* s, S_单色文本绘制ID& 文本ID, uint16 属性ID, uint16 字号);
//void f_ui绘制模板_凸边线绘制(S_2D画布* s, S_单色绘制ID& id, uint16 属性ID);
//void f_ui绘制模板_纹理面绘制(S_2D画布* s, S_单色绘制ID& id, uint16 属性ID, E_笔刷类型 笔刷类型);
//void f_ui绘制模板_单色线(S_2D画布* s, S_单色绘制ID& ID, uint16 属性ID);
//void f_ui绘制模板_边面凸边矩形绘制(S_2D画布* s, S_单色边面ID& id, uint16 属性ID, float32 线宽);



